package com.smartsofa.util;

import java.util.ArrayList;

import android.R.integer;
import android.content.Context;
import android.content.Intent;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.DashPathEffect;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.PathEffect;
import android.graphics.Point;
import android.graphics.Rect;
import android.graphics.Region;
import android.graphics.drawable.NinePatchDrawable;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;

import com.smartsofa.R;
import com.smartsofa.main.DayHistoryDisplay;


/**
 * Created by Dacer on 11/4/13.
 * Edited by Lee youngchan 21/1/14
 * Edited by dector 30-Jun-2014
 */
public class LineView extends View {
    private int mViewHeight;
    //drawBackground
    private boolean autoSetDataOfGird = true;
    private boolean autoSetGridWidth = true;
    private int dataOfAGird = 10;
    private int bottomTextHeight = 0;
    
    private int styleMode=1;
    private float mMax;
    private float mMin;
    
    //鏄惁鐢诲嚭鏁版嵁绾�
    private Boolean isDrawDataLine = true;
    private ArrayList<String> bottomTextList = new ArrayList<String>();
    
    private ArrayList<ArrayList<Float>> dataLists;
    private ArrayList<Float> dataList;
    
    private ArrayList<Integer> xCoordinateList = new ArrayList<Integer>();
    private ArrayList<Float> yCoordinateList1 = new ArrayList<Float>();
    private ArrayList<Float> yCoordinateList2 = new ArrayList<Float>();
    private ArrayList<ArrayList<Float>> yCoordinateLists = new ArrayList<ArrayList<Float>>();
    
    private ArrayList<ArrayList<Dot>> drawDotLists = new ArrayList<ArrayList<Dot>>();
    private ArrayList<Dot> drawDotList = new ArrayList<Dot>();
    
    private Paint bottomTextPaint = new Paint();
    private int bottomTextDescent;

    //popup
    private Paint popupTextPaint = new Paint();
    private final int bottomTriangleHeight = 12;
    public boolean showPopup = true; 

	private Dot pointToSelect;
	private Dot selectedDot;

    private int topLineLength = MyUtils.dip2px(getContext(), 12);; // | | 閳仭his
                                                                   //-+-+-
    private int sideLineLength = MyUtils.dip2px(getContext(),45)/3*2;// --+--+--+--+--+--+--
                                                                     //  閳唸his
    private int backgroundGridWidth = MyUtils.dip2px(getContext(),45);
    private LongPressRunnable longPressRunnable = new LongPressRunnable();

    //Constants
    private final int popupTopPadding = MyUtils.dip2px(getContext(),2);
    private final int popupBottomMargin = MyUtils.dip2px(getContext(),5);
    private final int bottomTextTopMargin = MyUtils.sp2px(getContext(),5);
    private final int bottomLineLength = MyUtils.sp2px(getContext(), 22);
    private final int DOT_INNER_CIR_RADIUS = MyUtils.dip2px(getContext(), 2);
    private final int DOT_OUTER_CIR_RADIUS = MyUtils.dip2px(getContext(),5);
    private final int MIN_TOP_LINE_LENGTH = MyUtils.dip2px(getContext(),12);
    private final int MIN_VERTICAL_GRID_NUM = 4;
    private final int MIN_HORIZONTAL_GRID_NUM = 1;
    private final int BACKGROUND_LINE_COLOR = Color.parseColor("#EEEEEE");
    private final int BOTTOM_TEXT_COLOR = Color.parseColor("#9B9A9B");
    
    public static final int SHOW_POPUPS_All = 1;
    public static final int SHOW_POPUPS_MAXMIN_ONLY = 2;
    public static final int SHOW_POPUPS_NONE = 3;
    
    public Boolean isExpendable = true;

    private int showPopupType =SHOW_POPUPS_NONE ;
    public void setShowPopup(int popupType) {
		this.showPopupType = popupType;
	}

	//闉濇劤鍔嗛熆婊屽珦
    private Boolean drawDotLine = false;
    //闇涙婢戞棊顒嗙叕
    private String[] colorArray = {"#e74c3c","#2980b9","#1abc9c"};
    //popup 鏃庮剢鐓�
    private int[] popupColorArray = {R.drawable.popup_red,R.drawable.popup_blue,R.drawable.popup_green};

    // onDraw optimisations
    private final Point tmpPoint = new Point();
    
	public void setDrawDotLine(Boolean drawDotLine) {
		this.drawDotLine = drawDotLine;
	}

	private Runnable animator = new Runnable() {
        @Override
        public void run() {
            boolean needNewFrame = false;
            for(ArrayList<Dot> data : drawDotLists){
            	for(Dot dot : data){
                    dot.update();
                    if(!dot.isAtRest()){
                        needNewFrame = true;
                    }
                }
            }
            if (needNewFrame) {
                postDelayed(this, 25);
            }
            invalidate();
        }
    };

    public LineView(Context context){
        this(context,null);
       
        
    }
    public LineView(Context context, AttributeSet attrs){
        super(context, attrs);
        
        popupTextPaint.setAntiAlias(true);
        popupTextPaint.setColor(Color.WHITE);
        popupTextPaint.setTextSize(MyUtils.sp2px(getContext(), 13));
        popupTextPaint.setStrokeWidth(5);
        popupTextPaint.setTextAlign(Paint.Align.CENTER);

        bottomTextPaint.setAntiAlias(true);
        bottomTextPaint.setTextSize(MyUtils.sp2px(getContext(),12));
        bottomTextPaint.setTextAlign(Paint.Align.CENTER);
        bottomTextPaint.setStyle(Paint.Style.FILL);
        bottomTextPaint.setColor(BOTTOM_TEXT_COLOR);
        
    }

    /**
     * dataList will be reset when called is method.
     * @param bottomTextList The String ArrayList in the bottom.
     */
    public void setBottomTextList(ArrayList<String> bottomTextList){
        
        if(bottomTextList.size() == 0){
        	for(int i=0;i<10;i++){
        		bottomTextList.add(""+i+1);
        	}
        }
        else{
        	this.dataList = null;
            this.bottomTextList = bottomTextList;
        }
        yCoordinateLists.add(yCoordinateList1);
        yCoordinateLists.add(yCoordinateList2);
        Rect r = new Rect();
        int longestWidth = 0;
        String longestStr = "";
        bottomTextDescent = 0;
        for(String s:bottomTextList){
            bottomTextPaint.getTextBounds(s,0,s.length(),r);
            if(bottomTextHeight<r.height()){
                bottomTextHeight = r.height();
            }
            if(autoSetGridWidth&&(longestWidth<r.width())){
                longestWidth = r.width();
                longestStr = s;
            }
            if(bottomTextDescent<(Math.abs(r.bottom))){
                bottomTextDescent = Math.abs(r.bottom);
            }
        }

        if(autoSetGridWidth){
            if(backgroundGridWidth<longestWidth){
                backgroundGridWidth = longestWidth+(int)bottomTextPaint.measureText(longestStr,0,1);
            }
            if(sideLineLength<longestWidth/2){
                sideLineLength = longestWidth/2;
            }
        }

        refreshXCoordinateList(getHorizontalGridNum());
    }

    /**
     *
     * @param dataLists The Integer ArrayLists for showing,
     *                 dataList.size() must < bottomTextList.size()
     */
    public void setDataLists(ArrayList<ArrayList<Float>> dataLists){
    	
        if(dataLists.size() == 0){
        	for(int i=0;i<10;i++){
        		dataList.add((float) 0);
        	}
        	dataLists.add(dataList);
        }
        else{
        	selectedDot = null;
            this.dataLists = dataLists;
        }
        for(ArrayList<Float> list : dataLists){        	
        	if(list.size() > bottomTextList.size()){
        		System.out.println("list.size():"+list.size()+"bottomTextList.size():"+bottomTextList.size());
                throw new RuntimeException("dacer.LineView error:" +
                        " dataList.size() > bottomTextList.size() !!!");
            }
        }
        float biggestData = 0;
        for(ArrayList<Float> list : dataLists){
        	if(autoSetDataOfGird){
                for(Float i:list){
                    if(biggestData<i){
                        biggestData = i;
                    }
                }
        	}
        	dataOfAGird = 1;
        	while(biggestData/10 > dataOfAGird){
        		dataOfAGird *= 10;
        	}
        }
        
        refreshAfterDataChanged();
        showPopup = true;
        setMinimumWidth(0); // It can help the LineView reset the Width,
                                // I don't know the better way..
        postInvalidate();
    }

    private void refreshAfterDataChanged(){
        float verticalGridNum = getVerticalGridlNum();
        int horizontalGridNum = getHorizontalGridNum();
        refreshTopLineLength(verticalGridNum);
        refreshYCoordinateList(verticalGridNum);
        refreshXCoordinateList(horizontalGridNum);
        refreshDrawDotList(verticalGridNum);
    }

    private float getVerticalGridlNum(){
        float verticalGridNum;
        switch(styleMode){
        case 1: 
        	mMax=200;
        	mMin=30;break;
        case 2: 
        	mMax=12;
        	mMin=3;break;
        case 3: 
        	mMax=100;
        	mMin=94;break;
        }
        verticalGridNum=mMax-mMin;
        return verticalGridNum;
    }

    private int getHorizontalGridNum(){
        int horizontalGridNum = bottomTextList.size()-1;
        if(horizontalGridNum<MIN_HORIZONTAL_GRID_NUM){
            horizontalGridNum = MIN_HORIZONTAL_GRID_NUM;
        }
        return horizontalGridNum;
    }

    private void refreshXCoordinateList(int horizontalGridNum){
        xCoordinateList.clear();
        for(int i=0;i<(horizontalGridNum+1);i++){
            xCoordinateList.add(sideLineLength + backgroundGridWidth*i);
        }

    }

    private void refreshYCoordinateList(float verticalGridNum){
        yCoordinateList1.clear();
        yCoordinateList2.clear();
        for(int k=0;k<dataLists.size();k++){
        	
        for(int i=0;i<dataLists.get(k).size();i++){        	
            yCoordinateLists.get(k).add(topLineLength +
                    ((mViewHeight-topLineLength-bottomTextHeight-bottomTextTopMargin-
                            bottomLineLength-bottomTextDescent)*(1-(dataLists.get(k).get(i)-mMin)/(verticalGridNum))));
            
            Log.i("log location",""+(dataLists.get(k).get(i)-mMin));
        }
        Log.i("ycolist",""+yCoordinateLists.get(k).size());
        }
        int size=yCoordinateLists.size();
        Log.i("ycor",""+size);
        Log.i("list",""+yCoordinateLists.get(size-1).size());
    }

    private void refreshDrawDotList(float verticalGridNum){
        if(dataLists != null && !dataLists.isEmpty()){
    		if(drawDotLists.size() == 0){
    			for(int k = 0; k < dataLists.size(); k++){
    				drawDotLists.add(new ArrayList<LineView.Dot>());
    			}
    		}
        	for(int k = 0; k < dataLists.size(); k++){
        		int drawDotSize = drawDotLists.get(k).isEmpty()? 0:drawDotLists.get(k).size();
        		
        		for(int i=0;i<dataLists.get(k).size();i++){
                    int x = xCoordinateList.get(i);
                    float y = yCoordinateLists.get(k).get(i);
                    if(i>drawDotSize-1){
                    	//闇冨嫶濮兼顒囧Б闊搁附銈� 鏂兼棄鐨滈爟婊婂珶.
                        drawDotLists.get(k).add(new Dot(i,x, 0.0f, x, y, dataLists.get(k).get(i),k));
                    }else{
                    	//闇冨嫶濮兼顒囧Б闊歌兂妫� 闊拷鐡寸喛娼� 闈广倢鐖奸爟婊婂珶.
                        drawDotLists.get(k).set(i, drawDotLists.get(k).get(i).setTargetData(x,y,dataLists.get(k).get(i),k));
                    }
                }
        		
        		int temp = drawDotLists.get(k).size() - dataLists.get(k).size();
        		for(int i=0; i<temp; i++){
        			drawDotLists.get(k).remove(drawDotLists.get(k).size()-1);
        		}
        	}
        }
        removeCallbacks(animator);
        post(animator);
    }

    private void refreshTopLineLength(float verticalGridNum){
        // For prevent popup can't be completely showed when backgroundGridHeight is too small.
        // But this code not so good.
        if((mViewHeight-topLineLength-bottomTextHeight-bottomTextTopMargin)/
                (verticalGridNum+2)<getPopupHeight()){
            topLineLength = getPopupHeight()+DOT_OUTER_CIR_RADIUS+DOT_INNER_CIR_RADIUS+2;
        }else{
            topLineLength = MIN_TOP_LINE_LENGTH;
        }
    }

    @Override
    protected void onDraw(Canvas canvas) {
    
        drawBackgroundLines(canvas);
        
        if(isDrawDataLine == true){
        drawStandardLines(canvas);      
        drawDots(canvas);
        if(dataLists.get(0).size()>1){
        	drawLines(canvas);
        	}
        }
        drawCoordinateLine(canvas);

        
       /* for(int k=0; k < drawDotLists.size(); k++){
        	float MaxValue = Collections.max(dataLists.get(k));
        	float MinValue = Collections.min(dataLists.get(k));
        	for(Dot d: drawDotLists.get(k)){
        		if(showPopupType == SHOW_POPUPS_All)
        			drawPopup(canvas, String.valueOf(d.data), d.setupPoint(tmpPoint),popupColorArray[k%3]);
        		else if(showPopupType == SHOW_POPUPS_MAXMIN_ONLY){
        			if(d.data == MaxValue)
        				drawPopup(canvas, String.valueOf(d.data), d.setupPoint(tmpPoint),popupColorArray[k%3]);
        			if(d.data == MinValue)
        				drawPopup(canvas, String.valueOf(d.data), d.setupPoint(tmpPoint),popupColorArray[k%3]);
        		}
        	}
        }*/
// 闈圭娍鍎╅爟锟� dot 姣碉拷 popup 闉氾拷 闇氼煃鐭� 闋冩粖瀚�.        
        if(showPopup && selectedDot != null){
            drawPopup(canvas,
                    String.valueOf(selectedDot.data),
                    selectedDot.setupPoint(tmpPoint),popupColorArray[selectedDot.linenumber%3]);
        }
    }

    /**
     *
     * @param canvas  The canvas you need to draw on.
     * @param point   The Point consists of the x y coordinates from left bottom to right top.
     *                Like is
     *                
     *                3
     *                2
     *                1
     *                0 1 2 3 4 5
     */
    private void drawPopup(Canvas canvas,String num, Point point,int PopupColor){
        boolean singularNum = (num.length() == 1);
        int sidePadding = MyUtils.dip2px(getContext(),singularNum? 8:5);
        int x = point.x;
        int y = point.y-MyUtils.dip2px(getContext(),5);
        Rect popupTextRect = new Rect();
        popupTextPaint.getTextBounds(num,0,num.length(),popupTextRect);
        Rect r = new Rect(x-popupTextRect.width()/2-sidePadding,
                y - popupTextRect.height()-bottomTriangleHeight-popupTopPadding*2-popupBottomMargin,
                x + popupTextRect.width()/2+sidePadding,
                y+popupTopPadding-popupBottomMargin);

        NinePatchDrawable popup = (NinePatchDrawable)getResources().getDrawable(PopupColor);
        popup.setBounds(r);
        popup.draw(canvas);
        canvas.drawText(num, x, y-bottomTriangleHeight-popupBottomMargin, popupTextPaint);
    }

    private int getPopupHeight(){
        Rect popupTextRect = new Rect();
        popupTextPaint.getTextBounds("9",0,1,popupTextRect);
        Rect r = new Rect(-popupTextRect.width()/2,
                 - popupTextRect.height()-bottomTriangleHeight-popupTopPadding*2-popupBottomMargin,
                 + popupTextRect.width()/2,
                +popupTopPadding-popupBottomMargin);
        return r.height();
    }
   
    //鐢荤偣
    private void drawDots(Canvas canvas){
        Paint bigCirPaint = new Paint();
        bigCirPaint.setAntiAlias(true);
        Paint smallCirPaint = new Paint(bigCirPaint);
        smallCirPaint.setColor(Color.parseColor("#FFFFFF"));
     
        if(drawDotLists!=null && !drawDotLists.isEmpty()){
        	for(int k=0; k < drawDotLists.size(); k++){	
        		bigCirPaint.setColor(Color.parseColor(colorArray[k%3]));
        		for(Dot dot : drawDotLists.get(k)){
                	canvas.drawCircle(dot.x,dot.y,DOT_OUTER_CIR_RADIUS,bigCirPaint);
                	canvas.drawCircle(dot.x,dot.y,DOT_INNER_CIR_RADIUS,smallCirPaint);
                	
					if(styleMode==1&&((dot.data>140||dot.data<90)&&k==0)||((dot.data>90||dot.data<60)&&k==1)){
						canvas.drawText(Float.toString(dot.data), dot.x-7, dot.y-10, bigCirPaint);       		
				    }
            	}
        		
        	}
        }
    }

    //鐢荤嚎
    private void drawLines(Canvas canvas){
        Paint linePaint = new Paint();
        linePaint.setAntiAlias(true);
        linePaint.setStrokeWidth(MyUtils.dip2px(getContext(), 2));
        for(int k = 0; k<drawDotLists.size(); k ++){
        	linePaint.setColor(Color.parseColor(colorArray[k%3]));
	        for(int i=0; i<drawDotLists.get(k).size()-1; i++){
	            canvas.drawLine(drawDotLists.get(k).get(i).x,
	                    drawDotLists.get(k).get(i).y,
	                    drawDotLists.get(k).get(i+1).x,
	                    drawDotLists.get(k).get(i+1).y,
	                    linePaint);
	        }
        }
    }
    //鐢诲潗鏍囩嚎
    private void drawCoordinateLine(Canvas canvas) {
    	float verticalGridNum = getVerticalGridlNum();
    	float delta = verticalGridNum/5;
    	Paint linePaint = new Paint();
    	 linePaint.setAntiAlias(true);
         linePaint.setStyle(Paint.Style.STROKE);
         linePaint.setStrokeWidth(MyUtils.dip2px(getContext(), 1f));
         linePaint.setColor(Color.parseColor("#7f7f7f"));
         int coordinateWidth = MyUtils.dip2px(getContext(), 6);
         canvas.drawLine(sideLineLength,
        		 mViewHeight - bottomTextTopMargin - bottomTextHeight-bottomTextDescent,
        		 getWidth(), 
        		 mViewHeight - bottomTextTopMargin - bottomTextHeight-bottomTextDescent,linePaint);
         canvas.drawLine(xCoordinateList.get(0),
                 0,
                 xCoordinateList.get(0),
                 mViewHeight - bottomTextTopMargin - bottomTextHeight-bottomTextDescent,
                 linePaint);
         for(int i=0;i<6;i++){
        	 float y=topLineLength +
                     ((mViewHeight-topLineLength-bottomTextHeight-bottomTextTopMargin-
                             bottomLineLength-bottomTextDescent)*(1-( mMax-i*delta-mMin)/(verticalGridNum)));
        	 canvas.drawLine(sideLineLength,
        			 y,
        			 sideLineLength+coordinateWidth, 
        			 y, linePaint);  
        	 y=topLineLength +
                ((mViewHeight-topLineLength-bottomTextHeight-bottomTextTopMargin-
         bottomLineLength-bottomTextDescent)*(1-( mMax-i*delta-mMin)/(verticalGridNum)))+MyUtils.dip2px(getContext(),5);
        	 
             float x=sideLineLength+coordinateWidth*4;
             canvas.drawText(""+(mMax-i*delta), x, y, bottomTextPaint);
             
         }
         
        
         
		
	}
    //鐢绘爣鍑嗙嚎
    private void drawStandardLines(Canvas canvas){
        Paint linePaint = new Paint();        
        float verticalGridNum = getVerticalGridlNum();
        linePaint.setAntiAlias(true);
        linePaint.setStyle(Paint.Style.STROKE);
        linePaint.setStrokeWidth(MyUtils.dip2px(getContext(), 1f));
        linePaint.setColor(Color.parseColor("#32CD32"));
        PathEffect effects = new DashPathEffect(
                new float[]{10,5,10,5}, 1);
        linePaint.setPathEffect(effects);
        switch(styleMode){
        case 1:
        	int[] standard_value1={60,90,140};
            for(int i=0;i<3;i++){
            	float y=topLineLength +
                        ((mViewHeight-topLineLength-bottomTextHeight-bottomTextTopMargin-
                                bottomLineLength-bottomTextDescent)*(1-( standard_value1[i]-mMin)/(verticalGridNum)));
            	
    			canvas.drawLine(sideLineLength,y,
    					getWidth(),
    					y, linePaint);
            }
        	break;
        case 2:
        	float[] standard_value2={3.9f,11.1f};
            for(int i=0;i<2;i++){
            	float y=topLineLength +
                        ((mViewHeight-topLineLength-bottomTextHeight-bottomTextTopMargin-
                                bottomLineLength-bottomTextDescent)*(1-( standard_value2[i]-mMin)/(verticalGridNum)));
    			canvas.drawLine(sideLineLength,y,
    					getWidth(),
    					y, linePaint);
            }
        	break;
        case 3:
        	int[] standard_value3={95,98};
            for(int i=0;i<2;i++){
            	float y=topLineLength +
                        ((mViewHeight-topLineLength-bottomTextHeight-bottomTextTopMargin-
                                bottomLineLength-bottomTextDescent)*(1-( standard_value3[i]-mMin)/(verticalGridNum)));
            	canvas.drawLine(sideLineLength,y,
    					getWidth(),
    					y, linePaint);
            }
        	break;
        }
       
       
    }
    
    
     private void drawBackgroundLines(Canvas canvas){
        Paint paint = new Paint();
        paint.setStyle(Paint.Style.STROKE);
        paint.setStrokeWidth(MyUtils.dip2px(getContext(),1f));
        paint.setColor(BACKGROUND_LINE_COLOR);
        PathEffect effects = new DashPathEffect(
                new float[]{10,5,10,5}, 1);

        //draw vertical lines
        for(int i=0;i<xCoordinateList.size();i++){
            canvas.drawLine(xCoordinateList.get(i),
                    0,
                    xCoordinateList.get(i),
                    mViewHeight - bottomTextTopMargin - bottomTextHeight-bottomTextDescent,
                    paint);
        }
        
        //draw dotted lines
      paint.setPathEffect(effects);
      Path dottedPath = new Path();
//      for(int i=0;i<yCoordinateList.size();i++){
//          if((yCoordinateList.size()-1-i)%dataOfAGird == 0){
//              dottedPath.moveTo(0, yCoordinateList.get(i));
//              dottedPath.lineTo(getWidth(), yCoordinateList.get(i));
//              canvas.drawPath(dottedPath, paint);
//          }
//      }
    	  //draw bottom text
      if(bottomTextList != null){
    	  for(int i=0;i<bottomTextList.size();i++){
				canvas.drawText(bottomTextList.get(i), sideLineLength
						+ backgroundGridWidth * i, mViewHeight
						- bottomTextDescent, bottomTextPaint);
    	  }
      }
      
     /* if(!drawDotLine){
    	//draw solid lines
          for(int i=0;i<yCoordinateList1.size();i++){
              if((yCoordinateList1.size()-1-i)%dataOfAGird == 0){
                  canvas.drawLine(0,yCoordinateList1.get(i),getWidth(),yCoordinateList1.get(i),paint);
              }
          }
      }*/
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        int mViewWidth = measureWidth(widthMeasureSpec);
        mViewHeight = measureHeight(heightMeasureSpec);
//        mViewHeight = MeasureSpec.getSize(measureSpec);
//        refreshAfterDataChanged();
        setMeasuredDimension(mViewWidth,mViewHeight);
    }

    private int measureWidth(int measureSpec){
        int horizontalGridNum = getHorizontalGridNum();
        int preferred = backgroundGridWidth*horizontalGridNum+sideLineLength*2;
        return getMeasurement(measureSpec, preferred);
    }

    private int measureHeight(int measureSpec){
        int preferred = 0;
        return getMeasurement(measureSpec, preferred);
    }

    private int getMeasurement(int measureSpec, int preferred){
        int specSize = MeasureSpec.getSize(measureSpec);
        int measurement;
        switch(MeasureSpec.getMode(measureSpec)){
            case MeasureSpec.EXACTLY:
                measurement = specSize;
                break;
            case MeasureSpec.AT_MOST:
                measurement = Math.min(preferred, specSize);
                break;
            default:
                measurement = preferred;
                break;
        }
        return measurement;
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
    	
    	if(isExpendable = true){
    	if (longPressRunnable != null) {
    		
        if (event.getAction() == MotionEvent.ACTION_DOWN) {
        	
            pointToSelect = findPointAt((int) event.getX(), (int) event.getY());
            
            
            
            if(pointToSelect != null){
                longPressRunnable.setPressLocation(findPointAt((int) event.getX(), (int) event.getY()));
                Log.i("event time",event.getEventTime()+"");
                Log.i("down time",event.getDownTime()+"");
                postDelayed(longPressRunnable, 500);
            	 }
            
          
        } else if (event.getAction() == MotionEvent.ACTION_UP) {
            if (pointToSelect != null) {
                selectedDot = pointToSelect;
                pointToSelect = null;
                postInvalidate();
                removeCallbacks(longPressRunnable);
               return true;
            }
        } 
        }
    	}else{
    		 if (event.getAction() == MotionEvent.ACTION_DOWN) {
    	            pointToSelect = findPointAt((int) event.getX(), (int) event.getY());
    	        } else if (event.getAction() == MotionEvent.ACTION_UP) {
    	            if (pointToSelect != null) {
    	                selectedDot = pointToSelect;
    	                pointToSelect = null;
    	                postInvalidate();
    	            }
    	        }
    	}
    	
    	
        return true;
       
    }

    private class LongPressRunnable implements Runnable {

        private Dot pointToSelectDot;

        public void setPressLocation( Dot pointToSelectDot) {
            this.pointToSelectDot = pointToSelectDot;
        }

        @Override
        public void run() {
        	Log.i("long click", "true");
        	Intent intent = new Intent(getContext(),DayHistoryDisplay.class);
        	intent.putExtra("date",bottomTextList.get(this.pointToSelectDot.index));
        	intent.putExtra("styleMode", styleMode);
        	getContext().startActivity(intent); 
        	performLongClick();
        }

    }

    

    private Dot findPointAt(int x, int y) {
        if (drawDotLists.isEmpty()) {
            return null;
        }

        final int width = backgroundGridWidth/2;
        final Region r = new Region();

        for (ArrayList<Dot> data : drawDotLists) {
            for (Dot dot : data) {
                final int pointX = dot.x;
                final int pointY = (int) dot.y;

                r.set(pointX - width, pointY - width, pointX + width, pointY + width);
                if (r.contains(x, y)){
                    return dot;
                }
            }
        }

        return null;
    }


    
    class Dot{
        int x;
        float y;
        float data;
        int targetX;
        float targetY;
        int linenumber;
        int index;
        int velocity = MyUtils.dip2px(getContext(),18);

        Dot(int index,int x,float y,int targetX,float targetY,Float data,int linenumber){
        	this.index = index;
            this.x = x;
            this.y = y;
            this.linenumber = linenumber;
            setTargetData(targetX, targetY,data,linenumber);
        }

        Point setupPoint(Point point) {
            point.set(x, (int) y);
            return point;
        }

        Dot setTargetData(int targetX,float targetY,Float data,int linenumber){
            this.targetX = targetX;
            this.targetY = targetY;
            this.data = data;
            this.linenumber = linenumber;
            return this;
        }

        boolean isAtRest(){
            return (x==targetX)&&(y==targetY);
        }

        void update(){
            x = updateSelf1(x, targetX, velocity);
            y = updateSelf2(y, targetY, velocity);
        }

        private int updateSelf1(int origin, int target, int velocity){
            if (origin < target) {
                origin += velocity;
            } else if (origin > target){
                origin-= velocity;
            }
            if(Math.abs(target-origin)<velocity){
                origin = target;
            }
            return origin;
        }
        private float updateSelf2(float origin, float target, int velocity){
            if (origin < target) {
                origin += velocity;
            } else if (origin > target){
                origin-= velocity;
            }
            if(Math.abs(target-origin)<velocity){
                origin = target;
            }
            return origin;
        }
    }
    public void setStyleMode(int styleMode){
    	this.styleMode=styleMode;
    }
    public int getStyleMode(){
    	return this.styleMode;
    }
    public void setDrawDataLineState( Boolean ifornot){
    	this.isDrawDataLine = ifornot;
    }
    public Boolean getDrawDataLineState(){
    	return this.isDrawDataLine;
    }
    public void setIsExpandable (Boolean isExpendable) {
		this.isExpendable = isExpendable;
	}
}
